Typestate-Guided Fuzzer for Discovering Use-after-Free Vulnerabilities

© 2020 Association for Computing Machinery. Existing coverage-based fuzzers usually use the individual control flow graph (CFG) edge coverage to guide the fuzzing process, which has shown great potential in finding vulnerabilities. However, CFG edge coverage is not effective in discovering vulnerabilities such as use-after-free (UaF). This is because, to trigger UaF vulnerabilities, one needs not only to cover individual edges, but also to traverse some (long) sequence of edges in a particular order, which is challenging for existing fuzzers. To this end, we propose to model UaF vulnerabilities as typestate properties, and develop a typestateguided fuzzer, named UAFL, for discovering vulnerabilities violating typestate properties. Given a typestate property, we first perform a static typestate analysis to find operation sequences potentially violating the property. Our fuzzing process is then guided by the operation sequences in order to progressively generate test cases triggering property violations. In addition, we also employ an information flow analysis to improve the efficiency of the fuzzing process. We have performed a thorough evaluation of UAFL on 14 widely-used real-world programs. The experiment results show that UAFL substantially outperforms the state-of-the-art fuzzers, including AFL, AFLFast, FairFuzz, MOpt, Angora and QSYM, in terms of the time taken to discover vulnerabilities. We have discovered 10 previously unknown vulnerabilities, and received 5 new CVEs

Efficient Countermeasures for Software Vulnerabilities due to Memory Management Errors (Efficiënte tegenmaatregelen voor softwarekwetsbaarheden veroorzaakt door geheugenbeheerfouten)

Ondanks vele jaren van onderzoek en grote investeringen door bedrijven, is de ontwikkeling van veilige software nog steeds een groot probleem. Dit blijkt uit de gestage toename van de kwetsbaarheden die jaarlijks zijn gemeld. Snelle verspreidende wormen zoals de worm Code Red, die naar schatting een wereldwijd economisch verlies van $2,62 miljard heeft veroorzaakt, zullen vaak fouten in programma's uitbuiten om zich snel te verspreiden.Kwetsbaarheden die kunnen uitgebuit worden door aanvallers voor het uitvoeren van code injectie aanvallen zijn een belangrijke vorm van implementatiefouten. De worm Code Red buit een bufferoverloop uit om willekeurige code te kunnen uitvoeren op de kwetsbare machine, waardoor hij zichzelf kan verspreiden door zich te kopiëren naar machines die hij besmet. Het wijdverspreide gebruik van C-achtige talen waar dergelijke kwetsbaarheden een belangrijk probleem zijn heeft het probleem verergerd. In dit proefschrift onderzoeken we een aantal kwetsbaarheden in C-achtige talen, die door aanvallers kunnen worden uitgebuit voor het uitvoeren van code injectie aanvallen en bespreken we tegenmaatregelen die bescherming bieden tegen dit soort aanvallen. Dit proefschrift bestaat uit drie belangrijke onderdelen: het begint met de presentatie van een uitgebreide inventarisatie van de huidig bekende kwetsbaarheden en tegenmaatregelen, dit wordt gevolgd door een discussie van twee nieuwe tegenmaatregelen die gericht zijn op een betere bescherming tegen aanvallen op verschillende kwetsbaarheden terwijl die slechts een te verwaarlozen invloed hebben op performantie.De inventarisatie biedt een uitgebreid en gestructureerd overzicht vankwetsbaarheden en tegenmaatregelen voor code injectie in C-achtige talen.Diverse tegenmaatregelen maken verschillende afwegingen in termenvan performantie, effectiviteit, geheugenverbruik, compatibiliteit, enz.Dit maakt het moeilijk te beoordelen en vergelijken van de geschiktheid van de voorgesteldetegenmaatregelen in een gegeven context. Deze inventaristatie is eenclassificatie en evaluatie kader, op basis waarvan de voordelen ennadelen van tegenmaatregelen kunnen worden beoordeeld. Op basis van de opmerkingen en de conclusies die werden getrokken uit de inventarisatie, zijn twee tegenmaatregelen ontworpen, geïmplementeerd en geëvalueerd.De eerste tegenmaatregel die we beschrijven is een efficiënte tegenmaatregel tegen stapelvermorzelingsaanvallen. Onze tegenmaatregel maakt geen gebruik van geheime waarden(zoals kanaries) en beschermt tegen aanvallen waartegen gelijkaardige tegenmaatregelen niet beschermen.Onze techniek splitst de standaard stapel in meerdere stapels.De verdeling van de soorten gegevens aan één van destacks is gebaseerd op de kans dat een specifiek data-element ofweleen doelwit ofwel een bron van aanvallen is. We hebben deze tegenmaatregel ge\"implementeerd in een C-compiler voor Linux. De evaluatie toont aan dat de impact op performantie door het gebruik van onze tegenmaatregel verwaarloosbaar is.De tweede tegenmaatregel beschermt tegen aanvallen op hoop-gebaseerde bufferoverlopen en zwevende wijzers.Het wijzigen van de beheersinformatie die gebruikt wordt door de dynamische geheugenbeheerder is vaak een bron van een aanval op deze kwetsbaarheden.Alle bestaande tegenmaatregelen met lage impact op performantie maken gebruik van magische waarden, kanaries of andere probabilistische waarden die geheim moeten blijven. In het geval van magische waarden wordt een geheime waarde geplaatst vóór een cruciale geheugenlocatie en door toezicht te houden of de waarde is veranderd, kunnen overlopen opgespoord worden. Als aanvallers willekeurige geheugenlocaties kunnen lezen, dan kunnen ze deze tegenmaatregel omzeilen.Deze tegenmaatregel presenteert een aanpak die, wanneer toegepast op een memory allocator,zal beschermen tegen deze aanvalsvector zonder toevlucht te nemen tot magie.We hebben deze aanpak geïmplementeerd door het wijzigen van eenbestaande algemeen gebruikte geheugebeheerder. Uit testen blijkt dat deze tegenmaatregel een te verwaarlozen, soms zelfs positieve, invloed op performantie heeft.status: publishe

An Overview of Common Programming Security Vulnerabilities and Possible Solutions

Programming security vulnerabilities are the most common cause of software security breaches in current day computing. While these can easily be avoided by an attentive programmer, many programs still contain these kinds of vulnerabilities. This document will describe what the most commonly occuring ones are and will then explain how these can be abused to make a program do something it did not intend to do. We will then take a look at how a recent vulnerability in popular piece of software was exploited to allow an attacker to take control of the execution flow of that program. Several solutions exist to detect and prevent many, though not all, of the vulnerabilities described in this document in existing programs without requiring source code modifications, and in some cases without even requiring access to the source code to the applications. We will take an indepth look at how these solutions are implemented and what their effects are on legitimate programs, how they attempt to mitigate the restrictions they impose and what their impact is on the performance of the programs they attempt to protect. We will also describe if and how these solutions can be bypassed

Alphanumeric RISC ARM shellcode

With the sudden explosion of mobile devices, the ARM processor has become one of the most widespread CPU cores in the world. ARM processors offer a good trade-off between power usage and processing power, which makes it an excellent candidate for mobile and embedded devices. Most mobile phones and personal digital assistants feature an ARM processor. Only recently, however, these devices have become powerful enough to let users connect over the internet to various services, and to share information like we are used to on desktop PCs. Unfortunately, this introduces a number of security risks. Like PCs, native ARM applications are susceptible to attacks such as buffer overflows and other improper input validation abuse. Since up till recently only fully featured desktop computers were powerful enough to connect to the internet and disseminate information in a ubiquitous manner, most attacks have focussed on the dominant desktop processor, which is the x86 processor. Given the increased connectivity of ARM-based devices, and given the potential for misuse of these devices (for instance, by making a hacked phone call commercial numbers), attacks on these devices will become much more common than is now the case. A typical hurdle for exploit writers, is that the shellcode has to pass one or more filtering methods before reaching the vulnerable buffer. A filtering method is a method that does some simple input validation, for instance by stringently checking that input matches a particular predefined pattern. A popular regular expression for example is [a-zA-Z0-9] (possibly extended with "space"). Intrusion detection systems are also adding more checks to detect particular patterns of op codes to detect attacks against applications. For educational purposes, we describe in this article how to write alphanumeric shellcode for ARM. This is important, because alphanumeric strings typically pass more of these validation checks and tend to survive more data transformations (such as conversions from one encoding to another) than non-alphanumeric shellcode. Writing alphanumeric shellcode was not considered easily doable on RISC architectures, which use 4 byte instructions.status: publishe

Memory error exploits in C: vulnerabilities and countermeasures

In this book we examine a number of vulnerabilities in C-like languages that can be exploited by attackers to perform code injection attacks. Next, we discuss countermeasures that provide protection against these kinds of attacks. This book starts off by presenting a comprehensive and structured survey of vulnerabilities and countermeasures for code injection in C-like languages. Various countermeasures make different trade-offs in terms of performance, e¿ectivity, memory cost, compatibility, etc. This makes it hard to evaluate and compare the adequacy of proposed countermeasures in a given context. This survey defines a classification and evaluation framework, on the basis of which advantages and disadvantages of countermeasures can be assessed. This is followed by an in-depth discussion of two novel countermeasures which aim to better protect against attacks while having only a negligible impact on performance. The first countermeasure focuses on stack-based buffer overflows, while the second aims at heap- based buffer overflows and double frees. This book will be of interest to computer scientists and readers interested in security and operating systems.nrpages: 176status: publishe